/**
 * 给定数组A，可以对所有元素同加或者同减
 * 给定Q个询问，对每个询问，给定Qi，问是否能够使得Qi等于数组元素的累乘
 * 显然数组A中不同元素的数量不能太多，否则必然溢出。
 * 其次注意到，给定Qi求是否为某些数的积比较麻烦，但是给定数求积比较容易
 * 所以采用预处理的方法
 * 
 * 首先对A统计Cnt, Cnt[i]表示数值i在A中出现的次数。
 * 然后计算数组A所有能够算出来的数，保存集合Ava中，Ava中初始就有零
 * 如果Cnt中有超过16种数，直接去回答问题即可
 * 
 * 令数组A形如: 1,...，这是累乘积的一个极小值点（非零情况下）
 * 1. 然后依次往右移动，进行累乘，当溢出以后就break
 * 2. 再依次往左移动，进行累乘，当溢出以后就break
 * 记录过程中出现的所有积
 * 
 * 再令数组A形如 ....,-1，这同样是一个极小值点
 * 1. 然后依次往右移动，进行累乘，当溢出以后就break
 * 2. 再依次往左移动，进行累乘，当溢出以后就break
 * 记录过程中出现的所有积
 * 
 * 对每一个询问，直接在Ava中查询即可。
 * 
 * 最多移动sqrt(1E9)次，当A中仅有2个相同元素时。
 * 所以与处理过程最差是O(4*sqrt(1E9)*16)，实际上到不了
 * 空间复杂度即Ava的size最多也是O(sqrt(1E9))的 
 */
#include <bits/stdc++.h>
using namespace std;

#include <bits/extc++.h>
using namespace __gnu_pbds;

using llt = __int128_t;
using Real = double;
using vi = vector<int>;
using pii = pair<int, int>;

int N, Q;
vi A;

map<int, int> Cnt;
set<llt> Ava;

llt const INF = 1E9 + 10;

bool checkOverflow(llt q, llt cha){
    if(q < 0) q = -q;

    int z = 0;
    llt s = 1;
    for(const auto & p : Cnt){
        auto tmp = p.first + cha;
        if(0 == tmp) return false;
        if(tmp < 0) tmp = -tmp;
        s *= tmp;
        if(s > q) return true;
    }
    return false;
}

pair<int, llt> calc(llt cha){
    if(checkOverflow(INF, cha)) return {-1, 0LL};
    llt s = 1;
    for(const auto & p : Cnt){
        llt tmp = p.first + cha;
        if(0 == tmp) return {true, 0LL};
        if(1 == tmp) continue;
        if(-1 == tmp) {
            if(p.second & 1) s= -s;
            continue;
        }
        for(int i=0;i<p.second;++i){
            s = s * tmp;
            if(s > INF) return {1, 0LL};
        }
    }
    return {0, s};
}

void proc(){
    Cnt.clear();
    for(auto i : A) Cnt[i] += 1;

    Ava.clear(); Ava.insert(0);
    if(Cnt.size() >= 16) goto L;

    for(int start=-1;;++start){
        auto cha = start - Cnt.begin()->first;
        auto tmp = calc(cha);
        if(0 == tmp.first) Ava.insert(tmp.second);
        else if(-1 == tmp.first) break;
    }

    for(int start=-1;;--start){
        auto cha = start - Cnt.begin()->first;
        auto tmp = calc(cha);
        if(0 == tmp.first) Ava.insert(tmp.second);
        else if(-1 == tmp.first) break;
    }
    for(int start=1;;--start){
        auto cha = start - Cnt.rbegin()->first;
        auto tmp = calc(cha);
        if(0 == tmp.first) Ava.insert(tmp.second);
        else if(-1 == tmp.first) break;
    }
    for(int start=1;;++start){
        auto cha = start - Cnt.rbegin()->first;
        auto tmp = calc(cha);
        if(0 == tmp.first) Ava.insert(tmp.second);
        else if(-1 == tmp.first) break;
    }
L:
    for(int m,q=1;q<=Q;++q){
        cin >> m;
        cout << (Ava.count(m) ? "Yes\n" : "No\n");
    }
}

int main(){
#ifndef ONLINE_JUDGE
    freopen("z.txt", "r", stdin);
#endif
    ios::sync_with_stdio(false);cin.tie(nullptr);cout.tie(0);
    int nofkase = 1;
    // cin >> nofkase;
    while(nofkase--){
        cin >> N >> Q;
        A.assign(N, {});
        for(auto & i : A) cin >> i;
        proc();
    }
    return 0;
}